package com.boarsoft.hibernate.dao;

import java.io.Serializable;
import java.util.List;

import org.hibernate.NonUniqueResultException;
import org.hibernate.Session;
import org.hibernate.query.NativeQuery;
import org.hibernate.query.Query;

import com.boarsoft.common.dao.PagedResult;

public interface SimpleDao {
	public <T> T get(Class<T> c, Serializable i);

	/**
	 * 
	 * @param clazz
	 * @param wql
	 *            eg: "and code=:code"
	 * @return
	 * @throws NonUniqueResultException
	 */
	public <T> T find(Class<T> clazz, String wql) throws NonUniqueResultException;

	public Object find(String hql);

	public <T> T find(String hql, Class<T> clazz);

	public Object save(Object o);

	public int executeUpdate(String hql);

	public boolean update(Object o);

	/**
	 * 调用merge时，hibernate会检查在持久化上下文中的持久化实例是否和脱管实例具有相同的标识符。<br/>
	 * 如果有，把脱管实例的状态负责到持久化实例中<br/>
	 * 如果没有，就从数据库中加载，然后把脱管实例和获取的对象状态合并<br/>
	 * 如果数据库中没有查到结果，就创建新的持久化实例<br/>
	 * 把脱管实例的状态复制到新实例，插入到数据库中，并通过merge操作返回<br/>
	 * 
	 * @param o
	 * @return
	 */
	public Object merge(Object o);

	public boolean delete(Class<?> c, Serializable i);

	public int executeHql(String hql);

	public int executeSql(String sql);

	public boolean delete(Class<?> c, Serializable[] dks);

	public boolean delete(Object o);

	public Object getValue(String hql);

	public int getTotal(Class<?> clazz);

	public int getTotal(String hql);

	public int getTotal(Class<?> clazz, String wql);

	public <T> List<T> list(Class<T> clazz);

	/**
	 * 执行HQL查询，返回所有clazz类型的实体列表
	 * 
	 * @param hql
	 * @param clazz
	 * @return
	 */
	public <T> List<T> list(String hql, Class<T> clazz);

	/**
	 * 
	 * @param hql
	 * @return
	 */
	public <T> List<T> list(String hql);

	/**
	 * 执行HQL查询，分页返回clazz类型的实体对象
	 * 
	 * @param hql
	 * @param clazz
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public <T> List<T> list(String hql, Class<T> clazz, int pageNo, int pageSize);

	/**
	 * 分页返回clazz类型的实体对象
	 * 
	 * @param clazz
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public <T> List<T> list(Class<T> clazz, int pageNo, int pageSize);

	public <T> List<T> list(Class<T> clazz, String wql);

	public <T> List<T> list(Class<T> clazz, String wql, int pageNo, int pageSize);

	/**
	 * 执行SQL，返回所有类型为clazz的实体对象
	 * 
	 * @param sql
	 * @param clazz
	 * @return
	 */
	public <T> List<T> listBySQL(String sql, Class<T> clazz);

	/**
	 * 执行SQL，分页返回所有类型为clazz的实体对象
	 * 
	 * @param sql
	 * @param clazz
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public <T> List<T> listBySQL(String sql, Class<T> clazz, int pageNo, int pageSize);

	public Object getValueBySQL(String sql);

	public void batchUpdate(List<?> lt, int max);

	public void batchSave(List<?> lt, int max);

	public void batchMerge(List<?> lt, int max);

	public void flushAndClear();

	public <T> NativeQuery<T> createSQLQuery(Class<T> clazz, String sql);

	public <T> Query<T> getNamedSQLQuery(String sql);

	/**
	 * 
	 * @param clazz
	 * @param hql
	 *            eg: "from Entity where code=:code"
	 * @return
	 */
	public <T> Query<T> createQuery(Class<T> clazz, String hql);

	/**
	 * 
	 * @param wql
	 *            eg: "and code=:code"
	 * @param clazz
	 * @return
	 */
	public <T> Query<T> createQuery(String wql, Class<T> clazz);

	public Session getASession();

	/**
	 * 将对象从受管状态变为脱管状态
	 * 
	 * @param o
	 */
	public void evict(Object o);

	void flush();

	/**
	 * 批量删除
	 * 
	 * @param lt
	 *            实体对象列表
	 * @param max
	 *            一次提交数
	 */
	void batchDelete(List<?> lt, int max);

	/**
	 * 获取命名的Query
	 * 
	 * @param name
	 * @return
	 */
	<T> Query<T> getNamedQuery(String name);

	/**
	 * 创建update/delete类型的Query时使用
	 * 
	 * @param string
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	Query createQuery(String string);

	/**
	 * 执行HQL分页查询
	 * 
	 * @param hql
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	<T> List<T> list(String hql, int pageNo, int pageSize);

	/**
	 * 执行SQL查询
	 *
	 * @param sql
	 * @return
	 */
	<T> List<T> listBySQL(String sql);

	/**
	 * 执行SQL分页查询
	 * 
	 * @param sql
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	<T> List<T> listBySQL(String sql, int pageNo, int pageSize);

	/**
	 * 
	 * @param sql
	 * @return
	 */
	<T> NativeQuery<T> createSQLQuery(String sql);

	/**
	 * 返回分页查询结果
	 * 
	 * @param clazz
	 * @param fql
	 * @param hql
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	<T> PagedResult<T> list(Class<T> clazz, String fql, String hql, int pageNo, int pageSize);

	/**
	 * 返回分页查询结果
	 * 
	 * @param clazz
	 * @param fql
	 * @param hql
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	<T> PagedResult<T> listBySQL(Class<T> clazz, String fql, String sql, int pageNo, int pageSize);

	/**
	 * 返回分页查询结果
	 * 
	 * @param clazz
	 * @param wql
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	<T> PagedResult<T> list2(Class<T> clazz, String wql, int pageNo, int pageSize);

	/**
	 * 返回分页查询结果
	 * 
	 * @param clazz
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	<T> PagedResult<T> list2(Class<T> clazz, int pageNo, int pageSize);
}